package com.jinzhi.wxpay.service.impl;



import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.jinzhi.wxpay.dao.OrderInfoMapper;
import com.jinzhi.wxpay.dao.ProductMapper;
import com.jinzhi.wxpay.entity.OrderInfo;
import com.jinzhi.wxpay.entity.OrderParme;
import com.jinzhi.wxpay.entity.ProductDO;
import com.jinzhi.wxpay.enums.OrderStatus;
import com.jinzhi.wxpay.service.OrderInfoService;
import com.jinzhi.wxpay.util.OrderNoUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Optional;

@Service
@Slf4j
public class OrderInfoServiceImpl extends ServiceImpl<OrderInfoMapper, OrderInfo> implements OrderInfoService {

    @Resource
    private ProductMapper productMapper;


    @Resource
    private  OrderInfoMapper  orderInfoMapper;

    /**SP
     * 生成订单
     * */
    @Override
    public OrderInfo createOrderByProductId(Long userId, Long productId) {
        //查找已存在但未支付的订单
        OrderInfo orderinfo = this.getNoPayOrderByProductId(userId, productId);
        if (orderinfo != null){//如果查询出来的数据不为空（说明订单存在）
                return  orderinfo;//直接返回对应的订单信息
        }

        log.info("开始生成订单");
        //使用商品id获取商品信息
        ProductDO productDO = productMapper.selectById(productId);
        //生成订单
        OrderInfo orderInfo = new OrderInfo();
        orderInfo.setTitle(productDO.getTitle());//商品标题（商品名）
        orderInfo.setOrderNo(OrderNoUtils.getOrderNo());//订单号（OrderNoUtils工具类中自动生成）
        orderInfo.setProductId(productId);//商品id
        orderInfo.setTotalFee(productDO.getPrice());//价格
        orderInfo.setOrderStatus(OrderStatus.NOT_PAY.getType());//订单状态（未支付）
        baseMapper.insert(orderInfo);
        return orderInfo;
    }


    /**JF
     * 积分购买生成订单
     * */
    @Override
    public OrderInfo createOrderByJF(String title, Long userId, BigDecimal totalFee) {
        //查找已存在但未支付的积分订单
        OrderInfo orderinfo = this.getNoPayOrderByJF(title,userId, totalFee);
        if (orderinfo != null){//如果查询出来的数据不为空（说明订单存在）
            return  orderinfo;//直接返回对应的订单信息
        }
        log.info("开始生成订单");
        OrderInfo orderInfo = new OrderInfo();
        orderInfo.setUserId(userId);//用户id
        orderInfo.setTitle(title);//商品标题（商品名）
        orderInfo.setOrderNo(OrderNoUtils.getOrderNo());//订单号（OrderNoUtils工具类中自动生成）
        orderInfo.setCreateTime(new Date());//订单时间
        //这里应为是直接在页面进行的购买，商品表中没有积分商品所以商品id不存在
//        BigDecimal totalFees = new BigDecimal(totalFee);//long类型转换为BigDecimal类型（应为数据库中金额字段是BigDecimal，该类型精度更高用于金额）
        orderInfo.setTotalFee(totalFee);//价格
        orderInfo.setOrderStatus(OrderStatus.NOT_PAY.getType());//订单支付状态（未支付）
        baseMapper.insert(orderInfo);
        return orderInfo;
    }

    @Override
    public OrderInfo createOrderByJFSum() {
        return null;
    }

    /**
     * 根据订单号更新订单状态
     * */
    @Override
    public void updateStatusByOrderNo(String orderNo, OrderStatus orderStatus) {
        log.info("更新订单状态====》",orderStatus.getType());
        Wrapper<OrderInfo> queryWrapper = new EntityWrapper<>();
        queryWrapper.eq("order_no",orderNo);
        OrderInfo orderInfo = new OrderInfo();
        orderInfo.setOrderStatus(orderStatus.getType());
        orderInfo.setUpdateTime(new Date());
        baseMapper.update(orderInfo,queryWrapper);
    }

    /**
     * 根据时间导出对应数据
     * */
    @Override
    public List<OrderInfo> OrderInfoExcel(OrderParme  orderParme) {
        return orderInfoMapper.OrderInfoExcel(orderParme);
    }


    /**
     * 根据订单id查询出对应订单的支付状态
     * */
    @Override
    public OrderInfo getOrderStatus(String orderNo){
//        Wrapper<OrderInfo> queryWrapper = new EntityWrapper<>();
//        queryWrapper.eq("order_no",orderNo);
        OrderInfo orderInfo1 = new OrderInfo();
        orderInfo1.setOrderNo(orderNo);
        OrderInfo orderInfo = baseMapper.selectOne(orderInfo1);
        if (orderInfo == null){//做一个判断（如果在数据库删除了这个订单信息，那么直接返回的情况下可能会出现空指针异常，这里做一个校验处理）
            return  null;
        }
        return  orderInfo;//返回订单状态
    }


    /**
     * 查询已存在未支付的订单
     * 防止用户未支付的情况下重复创建订单
     * */
    private OrderInfo getNoPayOrderByProductId(Long userId, Long productId){
//        Wrapper<OrderInfo> queryWrapper  = new EntityWrapper<>();
//        queryWrapper.eq("user_id",userId);//用户id
//        queryWrapper.eq("product_id",productId);//商品id
//        queryWrapper.eq("order_status", OrderStatus.NOT_PAY.getType());//订单状态
        OrderInfo orderInfo1 = new OrderInfo();
        orderInfo1.setUserId(userId);
        orderInfo1.setProductId(productId);
        orderInfo1.setOrderStatus(OrderStatus.NOT_PAY.getType());
        OrderInfo orderInfo = baseMapper.selectOne(orderInfo1);
        return orderInfo;
    }

    /**JF
     * 查询已存在未支付的积分订单
     * 防止用户未支付的情况下重复创建订单
     * */
    private OrderInfo getNoPayOrderByJF(String title, Long userId, BigDecimal totalFee){
//        Wrapper<OrderInfo> queryWrapper  = new EntityWrapper<>();
//        queryWrapper.eq("user_id",userId);//用户id
//        queryWrapper.eq("title",title);//积分名
//        queryWrapper.eq("total_fee",totalFee);//金额
//        queryWrapper.eq("order_status", OrderStatus.NOT_PAY.getType());//订单状态
        OrderInfo orderInfo1 = new OrderInfo();
        orderInfo1.setUserId(userId);
        orderInfo1.setTitle(title);
        orderInfo1.setTotalFee(totalFee);
        orderInfo1.setOrderStatus(OrderStatus.NOT_PAY.getType());
        OrderInfo orderInfo = baseMapper.selectOne(orderInfo1);
        return orderInfo;
    }




    /**
     * 存储订单二维码存储起来
     * 付款url可以存在两个小时，因此存储起来后，用户在打开还是可以进行付款
     * */
    @Override
    public void saveCodeUrl(String orderNo, String codeUrl) {
        //查询条件
        Wrapper<OrderInfo> queryWrapper = new EntityWrapper<>();
        queryWrapper.eq("order_no",orderNo);
        //要修改的字段
        OrderInfo orderInfo = new OrderInfo();
        orderInfo.setCodeUrl(codeUrl);

        baseMapper.update(orderInfo,queryWrapper);
    }


    /**
     *查询出订单列表，并根据订单创建时间进行倒序排序
     * */
    public Page<OrderParme> listOrderByCreateTimeDesc(int current, int number, OrderParme  orderParme){
        OrderParme orderParme1 = new OrderParme();
        List<OrderParme> list = new ArrayList<>();
        // 新建分页
        Page<OrderParme> page = new Page<OrderParme>(current, number);
        List<OrderInfo> orderInfos =  Optional.ofNullable(selectList(new EntityWrapper<OrderInfo>().eq("order_status","支付成功"))).orElse(new ArrayList<>());
        BigDecimal grossIncome = Optional.ofNullable(orderInfos.stream().map(OrderInfo::getTotalFee).
                reduce(BigDecimal.ZERO,BigDecimal::add)).orElse(new BigDecimal("0.0"));
        List<OrderInfo> orderInfoPage = baseMapper.listOrderByCreateTimeDesc(page,  orderParme);
        String userName = "";
        for (int i = 0;i < orderInfoPage.size();i++){
                    if (orderInfoPage.get(i).getName() != null&&!orderInfoPage.get(i).getName().equals("")){
                        userName = orderInfoPage.get(i).getName();
                    }else {
                        userName = orderInfoPage.get(i).getUsername();
                    }
            orderInfoPage.get(i).setName(userName);
        }


        orderParme1.setOrderInfoPage(orderInfoPage);//列表数据
        orderParme1.setGrossIncome(grossIncome);//总金额
        list.add(orderParme1);
        return  page.setRecords(list);
    }


    //查询出订单详情数据
    @Override
    public OrderInfo selectOrderXQ(Long id) {
        OrderInfo orderInfo = baseMapper.selectOrderXQ(id);
        return orderInfo;
    }


}
